home *** CD-ROM | disk | FTP | other *** search
/ InterCD 2000 September / september_2000.iso / intercd / root / ^Linux / cfengine-1.5.3 / src / wildcard.c < prev   
Encoding:
C/C++ Source or Header  |  1999-10-20  |  9.3 KB  |  295 lines
  1. /* cfengine for GNU
  2.  
  3.         Copyright (C) 1995
  4.         Free Software Foundation, Inc.
  5.  
  6.    This file is part of GNU cfengine - written and maintained 
  7.    by Mark Burgess, Dept of Computing and Engineering, Oslo College,
  8.    Dept. of Theoretical physics, University of Oslo
  9.  
  10.    This program is free software; you can redistribute it and/or modify it
  11.    under the terms of the GNU General Public License as published by the
  12.    Free Software Foundation; either version 2, or (at your option) any
  13.    later version.
  14.  
  15.    This program is distributed in the hope that it will be useful,
  16.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.    GNU General Public License for more details.
  19.  
  20.   You should have received a copy of the GNU General Public License
  21.   along with this program; if not, write to the Free Software
  22.   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
  23.  
  24. */
  25.  
  26.  
  27. #include "cf.defs.h"
  28. #include "cf.extern.h"
  29.  
  30.  
  31. /*************************************************************************/
  32. /* WILDCARD TOOLKIT : Level 0                                            */
  33. /*************************************************************************/
  34.  
  35. #define nomatch         0
  36. #define match           1
  37. #define maxlen          20
  38. #define startofstrings  10
  39. #define middleofstrings 11
  40. #define endofstrings    12
  41.  
  42. #define Wild(c)  (c == '*' || c == '?') ? true : false
  43.  
  44. #include <string.h>
  45.  
  46.  
  47. /*************************************************************************/
  48.  
  49. IsWildCard (str)
  50.  
  51. char *str;
  52.  
  53. {
  54. return (strchr(str,'?') || strchr(str,'*'));
  55. } 
  56.  
  57. /*************************************************************************/
  58.  
  59.  
  60.    WildMatch (wildptr,cmpptr)
  61.  
  62.    char *wildptr, *cmpptr;
  63.  
  64.    { char buffer[bufsize];
  65.      char *AfterSubString();
  66.      int i, status = startofstrings;
  67.      char lastwild = '\0';
  68.  
  69.    Debug1("WildMatch(%s,%s)\n",wildptr,cmpptr);
  70.      
  71.    if (strstr(wildptr,"*") == NULL && strstr(wildptr,"?") == NULL)
  72.       {
  73.       return (! strcmp(wildptr,cmpptr));
  74.       }
  75.  
  76.   while (true)
  77.       {
  78.       while (*wildptr == '?')                                /* 1 */
  79.          {
  80.          wildptr++;
  81.          cmpptr++;
  82.          if ((*cmpptr == '\0') && (*wildptr != '\0'))        /* 2 */
  83.             {
  84.             return(nomatch);
  85.             }
  86.          lastwild = '?';
  87.          status = middleofstrings;
  88.          }
  89.  
  90.       if (*wildptr == '\0' && *cmpptr == '\0')                /* 3 */
  91.          {
  92.          return(match);
  93.          }
  94.       else if (*wildptr == '\0')                              /* 4 */
  95.          {
  96.          return(nomatch);
  97.          }
  98.  
  99.       if (*wildptr == '*')                                    /* 5 */
  100.          {
  101.          while (*wildptr == '*')                              /* 6 */
  102.             {
  103.             wildptr++;
  104.             }
  105.          if (*wildptr == '\0')                                /* 7 */
  106.             {
  107.             if (*cmpptr == '\0')                              /* 8 */
  108.                {
  109.                return(nomatch);
  110.                }
  111.             else
  112.                {
  113.                return(match);
  114.                }
  115.             }
  116.  
  117.          cmpptr++;                                            /* 9 */
  118.          status = middleofstrings;
  119.          lastwild = '*';
  120.          }
  121.  
  122.       for (i = 0; !(Wild(*wildptr) || *wildptr == '\0'); i++) /* 10 */
  123.          {
  124.          buffer[i] = *wildptr++;
  125.          if (*wildptr == '\0')                                /* 11 */
  126.             {
  127.             status = endofstrings;
  128.             }
  129.          }
  130.  
  131.       buffer[i] = '\0';
  132.  
  133.       if ((cmpptr = AfterSubString(cmpptr,buffer,status,lastwild)) == NULL)
  134.          {
  135.          return(nomatch);                                      /* 12 */
  136.          }
  137.  
  138.       status = middleofstrings;
  139.       }
  140.    }
  141.  
  142. /******************************************************************/
  143. /* Wildcard Toolkit : Level 1                                     */
  144. /******************************************************************/
  145.  
  146.   char *AfterSubString(big,small,status,lastwild)
  147.  
  148.    /* If the last wildcard was a ? then this just tries to      */
  149.    /* match the substrings from the present position, otherwise */
  150.    /* looks for next occurrance of small within big and returns */
  151.    /* a pointer to the next character in big after small or     */
  152.    /* NULL if there is no string found to match                 */
  153.    /* If end of strings is signalled, make sure that the string */
  154.    /* is tied to the end of big. This makes sure that there is  */
  155.    /* correct alignment with end of string marker.              */
  156.  
  157.    char *big,*small;
  158.    int status;
  159.    char lastwild;
  160.  
  161.    { char *bigptr;
  162.  
  163.    if (strlen(small) > strlen(big))                       /* 13 */
  164.       {
  165.       return(NULL);
  166.       }
  167.  
  168.    if (lastwild == '?')                                   /* 14 */
  169.       {
  170.       if (strncmp(big,small,strlen(small)) == 0)
  171.          {
  172.          return(big+strlen(small));
  173.          }
  174.       else
  175.          {
  176.          return(NULL);
  177.          }
  178.       }
  179.  
  180.    if (status == endofstrings)                             /* 15 */
  181.       {
  182.       big = big + strlen(big) - strlen(small);
  183.       }
  184.  
  185.    for (bigptr = big; *bigptr != '\0'; ++bigptr)           /* 16 */
  186.       {
  187.       if (strncmp(bigptr,small,strlen(small)) == 0)
  188.          {
  189.          return(bigptr+strlen(small));
  190.          }
  191.  
  192.       if (status == startofstrings)                        /* 17 */
  193.          {
  194.          return(NULL);
  195.          }
  196.       }
  197.  
  198.    return(NULL);                                           /* 18 */
  199.    }
  200.  
  201. /******************************************************************
  202.  
  203. Comments :
  204.  
  205. 1. ? Matches a single character. Skip over with pointers.
  206. 2. Check that the compare string hasn't run out too soon.
  207. 3. If the wild-match is complete return MATCH!
  208. 4. other wise check that the wild card string hasn't run out
  209.    too soon.
  210.  
  211. 5. * Matches any string.
  212. 6. Skip over any *'s in the wildcard string and leave pointer
  213.    on the first character after.
  214. 7. If the last character in the wildstring is *, match any
  215.    remaining characters...
  216. 8. ...except no string at all. e.g. xyz* doesn't match xyz
  217. 9. Advancing this pointer by one, prevents * from matching
  218.    the null string even when the pointers haven't reached
  219.    the end of the string (so that the match is not complete).
  220.    This works because it screws up the pattern match in
  221.    the routine `AfterSubString()' by removing the first
  222.    character from a string which might otherwise match.
  223.    e.g. it stops *.c from matching .c because the strings
  224.    which get passed to AfterSubString are `.c' (from *.c)
  225.    and `c' (from .c).
  226. 10.Isolate the next string sandwhiched between wild-cards
  227.    or string delimiters. Copy to buffer.
  228. 11.Make a note if we hit the end of wildstring in the process.
  229.    i.e. is this the end of the strings we're matching?
  230. 12.The call to this routine checks whether a match is
  231.    allowed between the isolated string and the comparison
  232.    string. If a match is allowed it updates the pointers
  233.    so that they point to the next characters after the
  234.    match. Otherwise it returns NULL.
  235.  
  236. AfterSubString()
  237.  
  238. 13. You can't find a string larger than big inside big!
  239.     (This could occur because of points 15. and 9.)
  240. 14. If the last wildcard was just to match a single
  241.     character then the string match must be anchored to
  242.     the current pointer locations.
  243. 15. If this is the end of the strings to be matched, then
  244.     make sure the match also correctly identifies which
  245.     pattern matches the END of the string. e.g.
  246.     to avoid confusion over *.abc in .abc.abc.abc
  247. 16. If the last wildcard was a * or none, then
  248.     use a forward floating comparision which can
  249.     skip over anyjunk characters looking for the next
  250.     occurrance of the string.
  251. 17. If this is the first two characters in the string
  252.     and there is no match, give up. This anchors the
  253.     floating match to the start to avoid
  254.     a*b matching xaxb by skipping over the first x!
  255. 18. If there is no match yet, there's no chance!
  256.  
  257. Test Data
  258. ----------
  259.  
  260. Wild String        Valid Match           No Match
  261. ------------       -----------          ----------
  262.  
  263. abcd                abcd
  264.  
  265. *mmm*               abcmmmabc            abcmmm
  266.                                          mmm
  267.  
  268. *j                  jjjj                 jjjjx
  269.  
  270. *.c                  a.c                  .c
  271.                      .c.c
  272. *y                   ayyyyyyy             ya
  273.                                            y
  274.  
  275. ?a                    aa                   aaa
  276.                       ba                   ab
  277.  
  278. ???a                  aaaa                 ab
  279.                       xyza                 xyzaa
  280. ???                   xyz                  ab
  281.                                            abcd
  282. *                     anything
  283. *.*                   anything.anything
  284. a*                    abc                   a
  285.                                             bad
  286. ?mmm?                 ammmb                 abcmmmd
  287.                                             mmm
  288. a*b                   axyzb                 xyz
  289.                       abbb                  axab
  290.  
  291. *******************************************************************/
  292.  
  293.  
  294. /* EOF */
  295.